const mesh = @import("mesh.zig");
const std = @import("std");

test "new write read" {
    // 1. 选择一个分配器
    const allocator = std.testing.allocator;
    // const allocator = std.heap.page_allocator;
    // const bufeer = try allocator.alloc(u8, 600);
    // defer allocator.free(bufeer);
    // bufeer[0] = 'a';
    // _ = bufeer;
    // 2. 打开文件，获取 File 对象
    const file = try std.fs.cwd().openFile("data/cube.cell", .{});
    defer file.close(); // 使用 defer 确保文件被关闭
    const file_stat = try file.stat();
    std.debug.print("File size is: {} bytes\n", .{file_stat.size});

    // 3. 为 Reader 提供一个缓冲区
    var buffer: [4096]u8 = undefined; // 在栈上分配一个缓冲区

    // 4. 获取 Reader 接口实例，并传入缓冲区
    var file_reader = file.reader(&buffer); // 注意：这里需要传入缓冲区的引用
    const reader_interface = &file_reader.interface; // 获取实际的读取接口

    const content = try reader_interface.readAlloc(allocator, file_stat.size);
    defer allocator.free(content); // !!! 非常重要：必须释放 readAllAlloc 分配的内存 !!!
    std.debug.print("Read all content: {s}\n", .{content});
}
test "new write read1" {
    // std.mem.trim
    // 创建或打开目标文件
    const dst_file = try std.fs.cwd().createFile("data/destination.txt", .{});
    defer dst_file.close();

    // 为目标文件创建 Writer 并指定缓冲區
    var write_buffer: [4096]u8 = undefined;
    var writer = dst_file.writer(&write_buffer);

    const writer_interface = &writer.interface;
    try writer_interface.writeAll("test conetent");
    // 使用 sendFile 进行高效的文件拷贝（如果平台支持）
    // const bytes_copied = try writer.interface.sendFileAll(&reader, .unlimited);

    // 刷新 Writer 确保所有数据落地
    // try writer.interface.flush();
}

test "tokenize cell data" {
    const cell_data =
        \\CELL
        \\background_dim= 3
        \\manifold_dim= 2
        \\simplex= 0
        \\8 24 6
        \\-0.500000 -0.500000 0.500000
        \\0.500000 -0.500000 0.500000
        \\-0.500000 0.500000 0.500000
        \\0.500000 0.500000 0.500000
        \\-0.500000 0.500000 -0.500000
        \\0.500000 0.500000 -0.500000
        \\-0.500000 -0.500000 -0.500000
        \\0.500000 -0.500000 -0.500000
        \\2 0 1
        \\2 1 3
        \\2 3 2
        \\2 2 0
        \\2 2 3
        \\2 3 5
        \\2 5 4
        \\2 4 2
        \\2 4 5
        \\2 5 7
        \\2 7 6
        \\2 6 4
        \\2 6 7
        \\2 7 1
        \\2 1 0
        \\2 0 6
        \\2 1 7
        \\2 7 5
        \\2 5 3
        \\2 3 1
        \\2 6 0
        \\2 0 2
        \\2 2 4
        \\2 4 6
        \\4 0 1 2 3
        \\4 4 5 6 7
        \\4 8 9 10 11
        \\4 12 13 14 15
        \\4 16 17 18 19
        \\4 20 21 22 23
    ;
    // var line_iter = std.mem.tokenizeAny(u8, cell_data, "\r\n");
    // var line = line_iter.next() orelse return;
    // const cell_header_str = std.mem.trim(u8, line, "\r");
    // if (!std.mem.eql(u8, cell_header_str, "CELL")) {}

    // line = line_iter.next() orelse return;
    // var temp_iter = std.mem.tokenizeAny(u8, line, "= ");
    // var temp_key = temp_iter.next() orelse return;
    // var temp_value = temp_iter.next() orelse return;
    // const back_dim = try std.fmt.parseInt(usize, temp_value, 10);

    // line = line_iter.next() orelse return;
    // temp_iter = std.mem.tokenizeAny(u8, line, "= ");
    // temp_key = temp_iter.next() orelse return;
    // temp_value = temp_iter.next() orelse return;
    // const mani_dim = try std.fmt.parseInt(usize, temp_value, 10);

    // std.debug.print("test back dim{} mani dim{}\n", .{ back_dim, mani_dim });

    // std.debug.print("{s}\n", .{line});
    // try std.testing.expect(std.mem.eql(u8, cell_header_str, "CELL"));
    const allocator = std.testing.allocator;
    var m = try read_cell_str2smesh(
        f32,
        void,
        void,
        void,
        cell_data,
        allocator,
    );
    defer m.deinit(allocator);
    std.debug.print("sm .cells len:{}\n", .{m.data.non_simplex.cells.len});
    if (!m.isSimplex()) {
        std.debug.print("isnot siomplex\n", .{});
    }
    // std.fmt.parseInt
}

pub const Mesh_IO_Error = error{
    Mesh_IO_Error,
};
pub fn read_cell_str2smesh(
    comptime P: type,
    comptime VT: type,
    comptime CT: type,
    comptime MT: type,
    data_str: []const u8,
    allocator: std.mem.Allocator,
) !mesh.SmallestMesh(P, VT, CT, MT) {
    var m: mesh.SmallestMesh(P, VT, CT, MT) = undefined;
    var line_iter = std.mem.tokenizeAny(u8, data_str, "\r\n");

    //     // --- 你已完成的部分 ---
    var line = line_iter.next() orelse {
        return Mesh_IO_Error.Mesh_IO_Error;
    };
    const cell_header_str = std.mem.trim(u8, line, "\r");
    //     try std.testing.expect(std.mem.eql(u8, cell_header_str, "CELL"));
    if (!std.mem.eql(u8, cell_header_str, "CELL")) {
        return Mesh_IO_Error.Mesh_IO_Error;
    }
    line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
    var temp_iter = std.mem.tokenizeAny(u8, line, "= ");
    _ = temp_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error; // "background_dim"
    var temp_value = temp_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
    // std.debug.print("temp value:{s}\n", .{temp_value});
    const back_dim = try std.fmt.parseInt(usize, temp_value, 10);

    line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
    temp_iter = std.mem.tokenizeAny(u8, line, "= ");
    _ = temp_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error; // "manifold_dim"
    temp_value = temp_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
    m.dimension = try std.fmt.parseInt(u32, temp_value, 10);
    // 解析 simplex 标志
    line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
    temp_iter = std.mem.tokenizeAny(u8, line, "= ");
    _ = temp_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error; // "simplex"
    temp_value = temp_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;

    const is_simplex: bool = (try std.fmt.parseInt(u8, temp_value, 10)) != 0;
    line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;

    temp_iter = std.mem.tokenizeAny(u8, line, " ");
    const num_points = try std.fmt.parseInt(usize, temp_iter.next().?, 10);
    const num_halffaces = try std.fmt.parseInt(usize, temp_iter.next().?, 10);
    const num_cells = try std.fmt.parseInt(usize, temp_iter.next().?, 10);

    // 基于解析出的数量，为 mesh 分配内存
    m.points = try allocator.alloc([]P, num_points);
    m.points_prop = try allocator.alloc(VT, num_points);
    m.cells_prop = try allocator.alloc(CT, num_cells);
    m.prop = MT{};

    //     // 解析点坐标
    for (0..num_points) |i| {
        line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
        var coord_iter = std.mem.tokenizeAny(u8, line, " ");

        // 为单个点分配坐标空间
        m.points[i] = try allocator.alloc(P, back_dim);

        for (0..back_dim) |j| {
            const coord_str = coord_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
            m.points[i][j] = try std.fmt.parseFloat(P, coord_str);
        }
        m.points_prop[i] = VT{};
    }

    // 根据是否是单纯形来解析拓扑结构
    if (is_simplex) {
        // 本测试用例不是单纯形，所以这部分逻辑暂时不会执行
        const cells = try allocator.alloc([]usize, num_cells);
        m.data = .{ .simplex = .{ .cells = cells } };
        for (0..num_cells) |i| {
            line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
            var coord_iter = std.mem.tokenizeAny(u8, line, " ");

            // 为单个点分配坐标空间
            m.data.simplex.cells[i] = try allocator.alloc(usize, m.dimension + 1);

            for (0..(m.dimension + 1)) |j| {
                const coord_str = coord_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
                m.data.simplex.cells[i][j] = try std.fmt.parseInt(usize, coord_str, 10);
            }
            // std.fmt.par
            m.cells_prop[i] = CT{};
        }
    } else {
        // 解析非单纯形 (non-simplex)
        const halffaces = try allocator.alloc([]usize, num_halffaces);
        const cells = try allocator.alloc([]usize, num_cells);
        m.data = .{ .non_simplex = .{ .halffaces = halffaces, .cells = cells } };

        // 解析半面 (halffaces)
        for (0..num_halffaces) |i| {
            line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
            var hf_iter = std.mem.tokenizeAny(u8, line, " ");
            const hf_size = try std.fmt.parseInt(usize, hf_iter.next().?, 10);

            m.data.non_simplex.halffaces[i] = try allocator.alloc(usize, hf_size);
            for (0..hf_size) |j| {
                const p_idx_str = hf_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
                m.data.non_simplex.halffaces[i][j] = try std.fmt.parseInt(usize, p_idx_str, 10);
            }
        }

        // 解析单元 (cells)
        for (0..num_cells) |i| {
            line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
            var cell_iter = std.mem.tokenizeAny(u8, line, " ");
            const cell_size = try std.fmt.parseInt(usize, cell_iter.next().?, 10);

            m.data.non_simplex.cells[i] = try allocator.alloc(usize, cell_size);
            for (0..cell_size) |j| {
                const hf_idx_str = cell_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
                m.data.non_simplex.cells[i][j] = try std.fmt.parseInt(usize, hf_idx_str, 10);
            }
            m.cells_prop[i] = CT{};
        }
    }

    return m;
}
pub fn read_off_str2smesh(
    comptime P: type,
    comptime VT: type,
    comptime CT: type,
    comptime MT: type,
    data_str: []const u8,
    allocator: std.mem.Allocator,
) !mesh.SmallestMesh(P, VT, CT, MT) {
    var m: mesh.SmallestMesh(P, VT, CT, MT) = undefined;
    var line_iter = std.mem.tokenizeAny(u8, data_str, "\r\n");

    //     // --- 你已完成的部分 ---
    var line = line_iter.next() orelse {
        return Mesh_IO_Error.Mesh_IO_Error;
    };
    const cell_header_str = std.mem.trim(u8, line, "\r");
    //     try std.testing.expect(std.mem.eql(u8, cell_header_str, "CELL"));
    if (!std.mem.eql(u8, cell_header_str, "OFF")) {
        return Mesh_IO_Error.Mesh_IO_Error;
    }
    line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
    var temp_iter = std.mem.tokenizeAny(u8, line, " ");
    var temp_value = temp_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
    // std.debug.print("temp value:{s}\n", .{temp_value});
    const num_points = try std.fmt.parseInt(usize, temp_value, 10);
    temp_value = temp_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
    // std.debug.print("temp value:{s}\n", .{temp_value});
    const num_cells = try std.fmt.parseInt(usize, temp_value, 10);

    m.dimension = if (num_cells > 0) 2 else 9;

    // 解析 simplex 标志
    // line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
    // temp_iter = std.mem.tokenizeAny(u8, line, "= ");
    // _ = temp_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error; // "simplex"
    // temp_value = temp_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;

    // const is_simplex: bool = (try std.fmt.parseInt(u8, temp_value, 10)) != 0;
    // line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;

    // temp_iter = std.mem.tokenizeAny(u8, line, " ");
    // const num_points = try std.fmt.parseInt(usize, temp_iter.next().?, 10);
    // const num_halffaces = try std.fmt.parseInt(usize, temp_iter.next().?, 10);
    // const num_cells = try std.fmt.parseInt(usize, temp_iter.next().?, 10);

    // 基于解析出的数量，为 mesh 分配内存
    m.points = try allocator.alloc([]P, num_points);
    m.points_prop = try allocator.alloc(VT, num_points);
    m.cells_prop = try allocator.alloc(CT, num_cells);
    m.prop = MT{};

    //     // 解析点坐标
    for (0..num_points) |i| {
        line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
        var coord_iter = std.mem.tokenizeAny(u8, line, " ");

        // 为单个点分配坐标空间
        m.points[i] = try allocator.alloc(P, 3);

        for (0..3) |j| {
            const coord_str = coord_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
            m.points[i][j] = try std.fmt.parseFloat(P, coord_str);
        }
        m.points_prop[i] = VT{};
    }

    // 根据是否是单纯形来解析拓扑结构
    // 本测试用例不是单纯形，所以这部分逻辑暂时不会执行
    const cells = try allocator.alloc([]usize, num_cells);
    m.data = .{ .simplex = .{ .cells = cells } };
    for (0..num_cells) |i| {
        line = line_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
        var coord_iter = std.mem.tokenizeAny(u8, line, " ");

        // 为单个点分配坐标空间
        m.data.simplex.cells[i] = try allocator.alloc(usize, 3);

        for (0..3) |j| {
            const coord_str = coord_iter.next() orelse return Mesh_IO_Error.Mesh_IO_Error;
            m.data.simplex.cells[i][j] = try std.fmt.parseInt(usize, coord_str, 10);
        }
        // std.fmt.par
        m.cells_prop[i] = CT{};
    }
}
// test "tokenize cell data1" {
//     // 使用测试分配器，它会在测试结束时自动检查内存泄漏
//     const allocator = std.testing.allocator;

//     // 为 SmallestMesh 定义具体的泛型类型
//     // P: f64 (点坐标类型)
//     // VT, CT, MT: void (顶点、单元和网格的属性类型，本测试中不需要)
//     const MeshType = SmallestMesh(f64, void, void, void);
//     var mesh: MeshType = undefined;

//     // 使用 defer 来确保 deinit 总是在测试函数退出前被调用，以释放所有内存
//     defer mesh.deinit(allocator);

//     const cell_data =
//         \\CELL
//         \\background_dim= 3
//         \\manifold_dim= 2
//         \\simplex= 0
//         \\8 24 6
//         \\-0.500000 -0.500000 0.500000
//         \\0.500000 -0.500000 0.500000
//         \\-0.500000 0.500000 0.500000
//         \\0.500000 0.500000 0.500000
//         \\-0.500000 0.500000 -0.500000
//         \\0.500000 0.500000 -0.500000
//         \\-0.500000 -0.500000 -0.500000
//         \\0.500000 -0.500000 -0.500000
//         \\2 0 1
//         \\2 1 3
//         \\2 3 2
//         \\2 2 0
//         \\2 2 3
//         \\2 3 5
//         \\2 5 4
//         \\2 4 2
//         \\2 4 5
//         \\2 5 7
//         \\2 7 6
//         \\2 6 4
//         \\2 6 7
//         \\2 7 1
//         \\2 1 0
//         \\2 0 6
//         \\2 1 7
//         \\2 7 5
//         \\2 5 3
//         \\2 3 1
//         \\2 6 0
//         \\2 0 2
//         \\2 2 4
//         \\2 4 6
//         \\4 0 1 2 3
//         \\4 4 5 6 7
//         \\4 8 9 10 11
//         \\4 12 13 14 15
//         \\4 16 17 18 19
//         \\4 20 21 22 23
//     ;
//     var line_iter = std.mem.tokenizeAny(u8, cell_data, "\r\n");

//     // --- 你已完成的部分 ---
//     var line = line_iter.next() orelse return;
//     const cell_header_str = std.mem.trim(u8, line, "\r");
//     try std.testing.expect(std.mem.eql(u8, cell_header_str, "CELL"));

//     line = line_iter.next() orelse return;
//     var temp_iter = std.mem.tokenizeAny(u8, line, "= ");
//     _ = temp_iter.next() orelse return; // "background_dim"
//     var temp_value = temp_iter.next() orelse return;
//     const back_dim = try std.fmt.parseInt(usize, temp_value, 10);

//     line = line_iter.next() orelse return;
//     temp_iter = std.mem.tokenizeAny(u8, line, "= ");
//     _ = temp_iter.next() orelse return; // "manifold_dim"
//     temp_value = temp_iter.next() orelse return;
//     const mani_dim = try std.fmt.parseInt(usize, temp_value, 10);

//     // --- 继续完善的部分 ---

//     // 解析 simplex 标志
//     line = line_iter.next() orelse return;
//     temp_iter = std.mem.tokenizeAny(u8, line, "= ");
//     _ = temp_iter.next() orelse return; // "simplex"
//     temp_value = temp_iter.next() orelse return;
//     const is_simplex = (try std.fmt.parseInt(u8, temp_value, 10)) != 0;
//     try std.testing.expect(!is_simplex); // 根据数据，我们期望它不是单纯形

//     // 解析数量: points, halffaces, cells
//     line = line_iter.next() orelse return;
//     temp_iter = std.mem.tokenizeAny(u8, line, " ");
//     const num_points = try std.fmt.parseInt(usize, temp_iter.next().?, 10);
//     const num_halffaces = try std.fmt.parseInt(usize, temp_iter.next().?, 10);
//     const num_cells = try std.fmt.parseInt(usize, temp_iter.next().?, 10);

//     // 基于解析出的数量，为 mesh 分配内存
//     mesh.points = try allocator.alloc([]f64, num_points);
//     mesh.points_prop = try allocator.alloc(void, num_points);
//     mesh.cells_prop = try allocator.alloc(void, num_cells);
//     mesh.dimension = mani_dim;
//     mesh.prop = {};

//     // 解析点坐标
//     for (0..num_points) |i| {
//         line = line_iter.next() orelse return;
//         var coord_iter = std.mem.tokenizeAny(u8, line, " ");

//         // 为单个点分配坐标空间
//         mesh.points[i] = try allocator.alloc(f64, back_dim);

//         for (0..back_dim) |j| {
//             const coord_str = coord_iter.next() orelse return;
//             mesh.points[i][j] = try std.fmt.parseFloat(f64, coord_str);
//         }
//         mesh.points_prop[i] = {};
//     }

//     // 根据是否是单纯形来解析拓扑结构
//     if (is_simplex) {
//         // 本测试用例不是单纯形，所以这部分逻辑暂时不会执行
//         const cells = try allocator.alloc([]usize, num_cells);
//         mesh.data = .{ .simplex = .{ .cells = cells } };
//         // ... (此处应添加解析单纯形单元的逻辑)
//     } else {
//         // 解析非单纯形 (non-simplex)
//         const halffaces = try allocator.alloc([]usize, num_halffaces);
//         const cells = try allocator.alloc([]usize, num_cells);
//         mesh.data = .{ .non_simplex = .{ .halffaces = halffaces, .cells = cells } };

//         // 解析半面 (halffaces)
//         for (0..num_halffaces) |i| {
//             line = line_iter.next() orelse return;
//             var hf_iter = std.mem.tokenizeAny(u8, line, " ");
//             const hf_size = try std.fmt.parseInt(usize, hf_iter.next().?, 10);

//             mesh.data.non_simplex.halffaces[i] = try allocator.alloc(usize, hf_size);
//             for (0..hf_size) |j| {
//                 const p_idx_str = hf_iter.next() orelse return;
//                 mesh.data.non_simplex.halffaces[i][j] = try std.fmt.parseInt(usize, p_idx_str, 10);
//             }
//         }

//         // 解析单元 (cells)
//         for (0..num_cells) |i| {
//             line = line_iter.next() orelse return;
//             var cell_iter = std.mem.tokenizeAny(u8, line, " ");
//             const cell_size = try std.fmt.parseInt(usize, cell_iter.next().?, 10);

//             mesh.data.non_simplex.cells[i] = try allocator.alloc(usize, cell_size);
//             for (0..cell_size) |j| {
//                 const hf_idx_str = cell_iter.next() orelse return;
//                 mesh.data.non_simplex.cells[i][j] = try std.fmt.parseInt(usize, hf_idx_str, 10);
//             }
//             mesh.cells_prop[i] = {};
//         }
//     }

//     // --- 断言部分：验证解析结果 ---
//     try std.testing.expectEqual(@as(usize, 2), mesh.dimension);
//     try std.testing.expect(mesh.isSimplex() == false);

//     // 验证数量
//     try std.testing.expectEqual(num_points, mesh.points.len);
//     try std.testing.expectEqual(num_halffaces, mesh.data.non_simplex.halffaces.len);
//     try std.testing.expectEqual(num_cells, mesh.data.non_simplex.cells.len);

//     // 抽样验证具体数据
//     // 验证第一个点的坐标
//     try std.testing.expectEqual(@as(f64, -0.5), mesh.points[0][0]);
//     try std.testing.expectEqual(@as(f64, -0.5), mesh.points[0][1]);
//     try std.testing.expectEqual(@as(f64, 0.5), mesh.points[0][2]);

//     // 验证最后一个点的坐标
//     try std.testing.expectEqual(@as(f64, 0.5), mesh.points[7][0]);
//     try std.testing.expectEqual(@as(f64, -0.5), mesh.points[7][1]);
//     try std.testing.expectEqual(@as(f64, -0.5), mesh.points[7][2]);

//     // 验证第一个半面的顶点索引
//     try std.testing.expectEqualSlices(usize, &.{ 0, 1 }, mesh.data.non_simplex.halffaces[0]);

//     // 验证最后一个半面的顶点索引
//     try std.testing.expectEqualSlices(usize, &.{ 4, 6 }, mesh.data.non_simplex.halffaces[23]);

//     // 验证第一个单元的半面索引
//     try std.testing.expectEqualSlices(usize, &.{ 0, 1, 2, 3 }, mesh.data.non_simplex.cells[0]);

//     // 验证最后一个单元的半面索引
//     try std.testing.expectEqualSlices(usize, &.{ 20, 21, 22, 23 }, mesh.data.non_simplex.cells[5]);
// }
// pub fn parseCellData(
//     allocator: std.mem.Allocator,
//     data: []const u8,
// ) void {

//     // [性能关键点 1: 零拷贝分词]
//     // std.mem.tokenize 不会像其他语言的 split 函数那样，为每一个子字符串分配新的内存。
//     // 它返回一个迭代器，这个迭代器生成的'行'（line）切片，其指针直接指向原始的 `data` 内存区域。
//     // 这从根本上避免了因分割字符串而产生的大量小内存分配和数据拷贝，对于大文件来说，性能提升是巨大的。
//     var line_iter = std.mem.tokenize(u8, data, "\n");

//     // --- 1. 解析 Header ---
//     // 这个区域的代码重复三次，但每次操作都极其轻量。
//     // .next() 只是移动迭代器内部的指针和索引，trim 也只是调整切片的头尾指针，
//     // parseInt 直接在原始字节上进行数学转换。整个过程没有一次堆内存分配。
//     var line = line_iter.next() orelse return error.UnexpectedEndOfFile;
//     var kv_iter = std.mem.tokenize(u8, line, "=");
//     _ = kv_iter.next() orelse return error.InvalidHeaderFormat;
//     var val_bytes = std.mem.trim(u8, kv_iter.next() orelse return error.InvalidHeaderFormat, " \r\t");
//     cell.background_dim = try std.fmt.parseInt(u32, val_bytes, 10);

//     line = line_iter.next() orelse return error.UnexpectedEndOfFile;
//     kv_iter = std.mem.tokenize(u8, line, "=");
//     _ = kv_iter.next() orelse return error.InvalidHeaderFormat;

//     val_bytes = std.mem.trim(u8, kv_iter.next() orelse return error.InvalidHeaderFormat, " \r\t");
//     cell.manifold_dim = try std.fmt.parseInt(u32, val_bytes, 10);

//     line = line_iter.next() orelse return error.UnexpectedEndOfFile;
//     kv_iter = std.mem.tokenize(u8, line, "=");
//     _ = kv_iter.next() orelse return error.InvalidHeaderFormat;
//     val_bytes = std.mem.trim(u8, kv_iter.next() orelse return error.InvalidHeaderFormat, " \r\t");
//     cell.simplex = try std.fmt.parseInt(u32, val_bytes, 10);

//     // --- 2. 解析数量统计 ---
//     line = line_iter.next() orelse return error.UnexpectedEndOfFile;
//     // 同样，tokenizeAny 也是零拷贝的。
//     var count_iter = std.mem.tokenizeAny(u8, line, " \t\r");

//     // [性能关键点 4: 直接从字节解析]
//     // std.fmt.parseInt 直接在 `[]const u8` 切片上工作。它不需要先将字节转换为
//     // 一个标准库的 string 对象再解析，避免了中间数据结构的创建和内存拷贝。
//     const num_vertices = try std.fmt.parseInt(usize, count_iter.next() orelse return error.InvalidCountLine, 10);
//     const num_edges = try std.fmt.parseInt(usize, count_iter.next() orelse return error.InvalidCountLine, 10);
//     const num_faces = try std.fmt.parseInt(usize, count_iter.next() orelse return error.InvalidCountLine, 10);

//     // --- 3. 【性能关键点 2: 批量预分配】 ---
//     // 这是整个函数中性能表现的基石。我们已经提前知道了需要多少顶点、边和面，
//     // 所以我们向分配器请求三块 *连续的* 大内存。
//     // 这样做的好处是：
//     // a. 避免了在后续循环中，因为切片容量不足而需要反复进行`realloc`（重新分配、拷贝旧数据、释放旧内存）的昂贵操作。
//     // b. 内存连续性使得CPU缓存命中率更高，从而在后续访问这些数据时速度更快。
//     // c. 将所有堆分配操作集中到一处，减少了与系统内存管理器交互的次数。
//     cell.vertices = try allocator.alloc(Vertex, num_vertices);
//     cell.edges = try allocator.alloc(Edge, num_edges);
//     cell.faces = try allocator.alloc(Face, num_faces);

//     // [代码健壮性与性能]
//     // `errdefer` 是一个强大的 Zig 特性。如果在分配成功后、函数成功返回前的任何地方发生错误
//     //（例如，文件内容不完整导致解析失败），这个块会自动执行，确保已分配的内存被正确释放，
//     // 从而防止内存泄漏。它没有运行时开销，是在编译期安排好的错误处理路径。
//     errdefer {
//         allocator.free(cell.vertices);
//         allocator.free(cell.edges);
//         allocator.free(cell.faces);
//     }

//     // --- 4. 解析 Vertices 数据 ---
//     // [性能关键点 3: 循环体内无分配]
//     // 这个循环体非常“紧凑”（tight loop）。它只包含以下操作：
//     // a. 迭代器推进 (`line_iter.next()`)
//     // b. 零拷贝分词 (`tokenizeAny`)
//     // c. 直接字节解析 (`parseFloat`)
//     // d. 将结果写入预先分配好的内存 (`v.x = ...`)
//     // 整个循环过程中，**没有任何一次堆内存分配**。所有操作都在栈和已分配的`cell.vertices`内存上进行，
//     // 这使得循环的执行速度可以达到机器的极限。
//     for (cell.vertices) |*v| {
//         line = line_iter.next() orelse return error.UnexpectedEndOfFile;
//         var field_iter = std.mem.tokenizeAny(u8, line, " \t\r");

//         const x_str = field_iter.next() orelse return error.InvalidVertexLine;
//         const y_str = field_iter.next() orelse return error.InvalidVertexLine;
//         const z_str = field_iter.next() orelse return error.InvalidVertexLine;

//         v.x = try std.fmt.parseFloat(f64, x_str);
//         v.y = try std.fmt.parseFloat(f64, y_str);
//         v.z = try std.fmt.parseFloat(f64, z_str);
//     }

//     // --- 5. 解析 Edges 数据 ---
//     // 与上面的顶点解析同理，这个循环同样是零分配、高性能的。
//     for (cell.edges) |*e| {
//         line = line_iter.next() orelse return error.UnexpectedEndOfFile;
//         var field_iter = std.mem.tokenizeAny(u8, line, " \t\r");

//         _ = field_iter.next() orelse return error.InvalidEdgeLine;
//         const v1_str = field_iter.next() orelse return error.InvalidEdgeLine;
//         const v2_str = field_iter.next() orelse return error.InvalidEdgeLine;

//         e.v1 = try std.fmt.parseInt(u32, v1_str, 10);
//         e.v2 = try std.fmt.parseInt(u32, v2_str, 10);
//     }

//     // --- 6. 解析 Faces 数据 ---
//     // 同样，零分配、高性能。
//     for (cell.faces) |*f| {
//         line = line_iter.next() orelse return error.UnexpectedEndOfFile;
//         var field_iter = std.mem.tokenizeAny(u8, line, " \t\r");

//         _ = field_iter.next() orelse return error.InvalidFaceLine;
//         const e1_str = field_iter.next() orelse return error.InvalidFaceLine;
//         const e2_str = field_iter.next() orelse return error.InvalidFaceLine;
//         const e3_str = field_iter.next() orelse return error.InvalidFaceLine;
//         const e4_str = field_iter.next() orelse return error.InvalidFaceLine;

//         f.e1 = try std.fmt.parseInt(u32, e1_str, 10);
//         f.e2 = try std.fmt.parseInt(u32, e2_str, 10);
//         f.e3 = try std.fmt.parseInt(u32, e3_str, 10);
//         f.e4 = try std.fmt.parseInt(u32, e4_str, 10);
//     }

//     // 函数成功执行到这里，返回填充好的 CellData 结构体。
//     // [内存所有权转移]
//     // 此时，通过 allocator 分配的三块内存的所有权，从本函数转移给了调用者。
//     // 调用者现在有责任在未来某个时刻调用 `cell_data.deinit(allocator)` 来释放内存。
//     // 这种明确的所有权模型是Zig（以及C++/Rust）实现高性能和内存安全的核心。
//     return cell;
// }
